package org.example.test1;

import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        Integer c = 128;
        Integer d = 128;
        System.out.println(a == b);//true
        System.out.println(c == d);//falseInteger 是一个对象类型，a == b 比较的是对象引用是否相同（也就是是否指向同一个对象）。
//        Java 为了提升性能，对特定范围内的整型数创建了缓存对象。对于 Integer，这个缓存范围通常是 [-128, 127]（官方文档中描述的是 -128 到 127，具体实现可能因 JVM 而异，但大多数 HotSpot 实现是如此）。
//        当你用装箱（boxing）把字面量或表达式转成 Integer 对象时，如果数字落在缓存范围内，JVM 会直接返回缓存中的同一个对象，因此 a == b 结果为 true。
//        超出缓存范围的数字不会从缓存中取对象，而是创建新的 Integer 对象。这就导致不同的对象引用，即 c == d 为 false，尽管它们的值都为 128。
//        //封装类里提供了转换的方法
//        String a = "10";
//        int b = Integer.parseInt(a);
//        String c = "12.5";
//        double d = Double.parseDouble(c);
//        Integer bInt = b;
//        //int n = bInt;
//        System.out.println(bInt.toString()+12);//1012
//
    }
    /**
     * 调用带异常声明的方法,要么try catch异常处理,要么继续将方法做异常声明
     */
    public static void main13(String[] args) {
        try {
            int a = 8;
            int b = 0;
            System.out.println(a/b);
            System.exit(0);//强制退出程序,只有它能控制finally不执行
        }catch (InputMismatchException e){
            System.out.println("只能录入整数");
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }catch (Exception e){
            System.out.println(e.getMessage());
            System.err.println(e.getCause());
        }finally {
            System.out.println();
        }

    }

    /**
     * 接口: 是一种特殊的抽象类,抽象类主要是作为父类被子类继承,重写抽象方法,为多态做准备
     * 接口也一样,想让实现类(子类)实现(继承),重写抽象方法,为多态做准备
     * 接口的存在就是为了解决单继承问题,因为接口可以多实现
     * [public static final]
     * 接口里主要是一堆静态常量和抽象方法,大部分情况接口里就是一组抽象方法,接口就是一组功能
     *  实现类和接口是 has a 关系
     *
     * 接口类型的实现类对象,调用接口里的方法可以实现多态,接口可以多实现(implements *,*,*
     *
     */

    //方法重载的条件: 在同一个类里,方法名相同,但是参数不同(参数的数据类型/个数)
//重写,子类对父类

    //TODO final--变量 修饰变量转成常量,常量的值不允许修改;方法 不允许重写;类 不允许有子类
    public static void main12(String[] args) {
        //静态变量整个项目共享,类名. 调用,
        System.out.println(2*2*Area.pi);
    }
/*
TODO 面向对象的三个特征:封装,继承,多态
继承:实现代码复用,避免冗余,为多态做铺垫
逻辑上符合,子类is a 父类
继承的两个特性: 单根性(子类只有一个父类)  传递性(爷爷类->父类->子类)
super代表父类,this代表
向上转型: 子类对象可以自动转换成父类类型,转换后只能调用从父类继承过来的属性和方法
(父类类型强转成子类(may运行时错误)


 */
public static void main11(String[] args) {
    Pet[] pets = new Pet[2];
    pets[0] = new Pet() {
        @Override
        public String getName() {
            return super.getName();
        }
    };
   // pets[1] = new Dog();

}
public static void main10(String[] args) {
    Pet cat = new Cat();
    Pet dog = new Dog("hei",80,90);
    if(dog instanceof Dog){//判断引用类型
        Dog dog1 = (Dog) dog;
    }
}
/*
重写的条件:访问修饰符,返回值类型
 */
public static void main9(String[] args) {
    Cat cat = new Cat();
    cat.setName("hua");
    //cat.eat();
}

//public static void main(String[] args) {
//    Dog dog = new Dog();
//    dog.name = "heigou";
//    dog.health = 100;
//    dog.love = 100;
//    dog.print();
//}
    public static void main8(String[] args) {
        Game game = new Game();
        game.startGame();
    }
    public static void main7(String[] args) {
        Person person = new Person("Mrs.");
        int perFist = person.showFist();
        Computer computer = new Computer();
        computer.name = "yu";
        int comFist = computer.showFist();
        System.out.println(perFist);
        System.out.println(comFist);
    }
//无参方法的语法: public 返回值类型 方法名(){方法体;[return 返回值]}

    public static void main6(String[] args) {
//        Emoloyee e1 = new Emoloyee();
//        Emoloyee e2 = new Emoloyee();
//        e1.name = "张三风";
//        e1.showInfo();

    }
    public static void main5(String[] args) {

// TODO 99
  for (int i = 1; i <= 9; i++) {//第几行

            for (int j = 1; j <= i; j++ ) {
                System.out.print(j+"*"+i+"="+(i*j)+" ");
            }
            System.out.println();
        }//songti,4hao
        int[] s = {3,7,1,0,9};
        Arrays.sort(s);//对数组进行升序排序
        //录入一个数子,查找该数字在数组中是否存在
        Scanner in = new Scanner(System.in);
        int key = in.nextInt();//查找的值
        int low = 0;
        int high = s.length-1;
        //二分查找
        while (high >= low){
            int mid = (low + high) / 2;
            if (key < s[mid]){
                high = mid-1;
            }else if (key == mid){
                System.out.println("找到了"+mid);
                break;
            }else low = mid + 1;
        }
    }
    public static void main4(String[] args) {
        //冒泡
        //数组的初始化
        //TODO int[] nums = new int[6]{9,6,5,4,7,8};错误写法
        //        int[] nums = new int[]{9,6,5,4,7,8};正确
        int[] nums = {9,6,5,4,7,8};//简化写法
         //TODO 外层循环n-1,内层循环n-1-i;
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < nums.length-1-i; j++) {
               if (nums[j] > nums[j+1]){
                   int t = nums[j];
                   nums[j] = nums[j+1];
                   nums[j+1] = t;
               }
            }
        }
        for (int i = 0; i < 6; i++) {
            System.out.println(nums[i]);
        }


    }
    public static void main3(String[] args) {
        //声明数组,会在栈内存开辟一个空间,默认是空引用,null
        int[] scores;
        String[] names;
        //为数组在堆内存里根据指定的长度开辟连续的存储空间
        scores = new int[3];
        names = new String[3];
        //数组名是地址,
        // new完有默认值,和数组类型有关,
        //int--0;double,float--0.0;char-- (空格);引用类型--null;
        int[] nums = new int[5];
        Scanner in = new Scanner(System.in);
        for (int i = 0; i < nums.length; i++) {
            System.out.println("请录入"+(i+1)+"数据");
            nums[i] = in.nextInt();
        }
        //求最大值
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > max){
                max = nums[i];
            }
        }
    }
    public static void main2(String[] args) {
       //打印三角形1,3,5,7..
        for (int i = 1; i <= 5; i++) {//第几行

            for (int j = 1; j <= 2*i-1; j++ ) {
                System.out.print("*");

            }


            System.out.println();
        }

        for (int i = 1; i < 20; i++) {
            if (i % 2 == 0){
                continue;
            }
            System.out.println(i + " ");
        }
    }
    public static void main1(String[] args) {

        System.out.println("Hello world!");
        int num1 = 2;
        int num2 = 9;
        System.out.println(num2 / num1);
        System.out.println(9.0 % num1);
        int sum = (int) 3.5 + 2;
        int i1 = 12;
        int i2 = 45;
        double d1 = (i1 + i2) * 1.0;
        System.out.println(d1);
        float f3 = 12.3f;
        long l1 = 12300;
        long l2 =  30000000000l;
        float f = l2+l1+f3;
        byte m1 = 1;
        byte m2 = 1;
        byte m = (byte) (m1+m2);
        System.out.println(num1+"\t"+num2);//2      9(拼接)
        //a++,++a,a--,--a
        if(num1 >= 80 && num1 >= 90 || num1 >=70 && num1 >=100){
            System.out.println("123");//&&优先级高于||
        }
        //&&(短路与) 运算效率高于 &(非短路与) 运算方式有不同,结果一样
        //? :

        Scanner input = new Scanner(System.in);
        System.out.println("请输入名次(1,2,3):");
        int j = input.nextInt();
        if (j == 1){
            System.out.println("奖励夏令营");
        } else if (j == 2) {
            System.out.println("奖励电脑");
        }else if(j == 3)
            System.out.println("奖励手机");
        switch (j){
            case 1:
                System.out.println("奖励夏令营");
                break;
            case 2:
                System.out.println("奖励电脑");
                break;
            case 3:
                System.out.println("奖励手机");
                break;
            default:
                System.out.println("无奖励");
        }

        int month = input.nextInt();
        switch (j){
            case 3:

            case 4:

            case 5:
                System.out.println("不知细叶谁裁出,二月春风似剪刀");
                break;
            case 6:

            case 7:

            case 8:
                System.out.println("连雨不知春去,一晴方觉夏深");
                break;
            case 9:

            case 10:

            case 11:
                System.out.println("当年不肯嫁春风,无端却被秋风误");
                break;
            case 12:

            case 1:

            case 2:
                System.out.println("晚来天欲雪,能饮一杯无");
                break;
        }
        for (int i = 0; i < 5; i++) {
            int score = input.nextInt();

        }
    }
}